#include <iostream>
using namespace std;

// 内置类型
void Test()
{
	//除了用法方便，和malloc没什么区别
	// 管理对象
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);

	//管理对象数组
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	//动态申请10个int类型的空间，并初始化为1 2 3 4
	int* ptr7 = new int[10] {1, 2, 3, 4}; //后面的会默认初始化为0
	
	//释放一个对象
	delete ptr4; 
	delete ptr5;
	//释放多个对象
	delete[] ptr6; 
	delete[] ptr7;
}



// ————————————————————————自定义类型
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		//cout << "A():" << this << endl;
		cout << "A():" << endl;

	}
	A(int a1, int a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	
	A(const A& aa)
		: _a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		//cout << "~A()" << this << endl;
		cout << "~A()" << endl;

	}
private:
	int _a;
};

int main()
{
	// new/delete 和 malloc/free最大区别是
	// new/delete对于【自定义类型】除了开空间,还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(2);
	free(p1);
	delete p2;

	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;

	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10]; //调用10次构造函数
	free(p5);
	delete[] p6; //调用10次析造函数

	//多个对象
	A aa1(1);
	A aa2(2);
	A aa3(3);
	A* p7 = new A[10]{ aa1,aa2,aa3 };
	delete[]p7;
	// 多参数
	A* p7 = new A[10]{ 1,2,3,4,5,{6,7}};//用1生成临时对象，然后被编译器合二为一（隐式对象转换）
	delete[]p7;


	return 0;
}